In many computer systems, both the hardware and the software share the same bit-size environment. Since the hardware and the software are limited to the same address space, operations such as memory access are straightforward and do not require additional computation. For example, a 32-bit hardware platform is typically designed to support a 32-bit environment. A 32-bit software programming language operating in this environment can typically address up to 4 Gb of memory. In some systems, however, the hardware and the software have different bit length. This situation may arise when a new generation of hardware becomes available and is required to support existing software. For example, the Java programming language is currently implemented as a 32-bit language. A new 64-bit processor is designed to support a 64-bit Java Virtual Machine (VM) environment, in which more than 4 Gb of memory is available to the software operating in the VM environment. To access memory in the 64-bit Java VM environment using the 32-bit Java language typically requires converting 32-bit values into 64-bit addresses. The conversion usually costs extra processing cycles and introduces inefficiency to the system. It would be desirable if existing software programs and languages could operate on hardware devices that support a different bit length. It would also be useful if frequently occurring operations such as memory addressing could be implemented efficiently in such systems.